async def astream(self, chat_request: ChatRequest):
     """Stream the chat response tokens asynchronously."""
     original_language = chat_request.language
+    api_call_statuses = {}
     
     working_request = chat_request
+    
+    with Timer() as timer:
+        try:
+            # Handle Japanese translation with error handling
+            if original_language == "ja":
+                try:
+                    translated_question = translate_ja_to_en(
+                        chat_request.question, self.chat_config.ja_translation_model_name
+                    )
+                    working_request = ChatRequest(
+                        question=translated_question,
+                        chat_history=chat_request.chat_history,
+                        application=chat_request.application,
+                        language="en",
+                    )
+                except Exception as e:
+                    # Handle translation error similar to __acall__
+                    api_call_statuses["chat_success"] = False
+                    api_call_statuses["chat_error_info"] = ErrorInfo(
+                        has_error=True, error_message=str(e), 
+                        error_type=type(e).__name__, component="translation"
+                    ).model_dump()
+                    yield f"Translation error: {str(e)}"
+                    return
+                    
+            async for token in self.rag_pipeline.astream(
+                working_request.question, working_request.chat_history or []
+            ):
+                yield token
+                
+        except Exception as e:
+            # Handle streaming errors
+            api_call_statuses["chat_success"] = False
+            api_call_statuses["chat_error_info"] = ErrorInfo(
+                has_error=True, error_message=str(e),
+                error_type=type(e).__name__, component="chat"
+            ).model_dump()
+            yield f"Streaming error: {str(e)}"
+            return
+            
+        # Store final result with complete metadata
+        result = self.rag_pipeline.stream_result
+        result_dict = result.model_dump()
+        
+        # Handle response translation
+        if original_language == "ja":
+            try:
+                result_dict["answer"] = translate_en_to_ja(
+                    result_dict["answer"], self.chat_config.ja_translation_model_name
+                )
+            except Exception as e:
+                result_dict["answer"] = f"Translation error: {str(e)}\nOriginal answer: {result_dict['answer']}"
+                
+        # Update with complete metadata
+        api_call_statuses["chat_success"] = True
+        result_dict.update({
+            "application": chat_request.application,
+            "api_call_statuses": api_call_statuses,
+            "time_taken": timer.elapsed,
+            "start_time": timer.start,
+            "end_time": timer.stop,
+        })
+        
+        self.last_stream_response = ChatResponse(**result_dict)

 async def stream(self, inputs: RetrievalResult):
     """Stream response tokens while capturing the final result."""
     formatted_input = self._format_input(inputs)
     messages = self.get_messages(formatted_input)
     
     result = ""
     used_model = self.model
+    llm_api_status = None
+    
     try:
         async for token in self.model.stream(messages=messages):
             result += token
             yield token
+        llm_api_status = APIStatus(success=True, error_info=None)
     except Exception as e:
         logger.warning(f"Primary Response Synthesizer model failed, trying fallback: {str(e)}")
         used_model = self.fallback_model
-        async for token in self.fallback_model.stream(messages=messages):
-            result += token
-            yield token
+        result = ""  # Reset accumulator for fallback
+        try:
+            async for token in self.fallback_model.stream(messages=messages):
+                result += token
+                yield token
+            llm_api_status = APIStatus(success=True, error_info=None)
+        except Exception as fallback_e:
+            logger.error(f"Both primary and fallback Response Synthesizer models failed: {str(fallback_e)}")
+            llm_api_status = APIStatus(success=False, error_info=str(fallback_e))
+            raise Exception(f"Response synthesis streaming failed: {str(fallback_e)}")
     
     self.stream_output = {
         "query_str": formatted_input["query_str"],
         "context_str": formatted_input["context_str"],
         "response": result,
         "response_model": used_model.model_name,
         "response_synthesis_llm_messages": messages,
         "response_prompt": RESPONSE_SYNTHESIS_SYSTEM_PROMPT,
         "api_statuses": {
-            "response_synthesis_llm_api": None
+            "response_synthesis_llm_api": llm_api_status
         },
     }

+    def _build_pipeline_output(self, enhanced_query, response, retrieval_result) -> RAGPipelineOutput:
+        """Helper method to build RAGPipelineOutput consistently."""
+        return RAGPipelineOutput(
+            question=enhanced_query["standalone_query"],
+            answer=response["response"],
+            sources="\n".join(
+                [doc.metadata["source"] for doc in retrieval_result.documents]
+            ),
+            source_documents=response["context_str"],
+            system_prompt=response["response_prompt"],
+            model=response["response_model"],
+            total_tokens=0,
+            prompt_tokens=0,
+            completion_tokens=0,
+            time_taken=0,
+            start_time=datetime.datetime.now(),
+            end_time=datetime.datetime.now(),
+            api_call_statuses={
+                "web_search_success": retrieval_result.retrieval_info["api_statuses"]["web_search_api"].success,
+                "reranker_api_error_info": retrieval_result.retrieval_info["api_statuses"]["reranker_api"].error_info,
+                "reranker_api_success": retrieval_result.retrieval_info["api_statuses"]["reranker_api"].success,
+                "query_enhancer_llm_api_error_info": enhanced_query.get("api_statuses", {}).get("query_enhancer_llm_api", {}).error_info if enhanced_query.get("api_statuses") else None,
+                "query_enhancer_llm_api_success": enhanced_query.get("api_statuses", {}).get("query_enhancer_llm_api", {}).success if enhanced_query.get("api_statuses") else False,
+                "embedding_api_error_info": retrieval_result.retrieval_info["api_statuses"]["embedding_api"].error_info,
+                "embedding_api_success": retrieval_result.retrieval_info["api_statuses"]["embedding_api"].success,
+            },
+            response_synthesis_llm_messages=response.get("response_synthesis_llm_messages"),
+        )

-    async def astream(
-        self, question: str, chat_history: List[Tuple[str, str]] | None = None
-    ) -> None:
+    async def astream(
+        self, question: str, chat_history: List[Tuple[str, str]] | None = None
+    ) -> AsyncGenerator[str, None]:

-from typing import Dict, List, Tuple
+from typing import AsyncGenerator, Dict, List, Tuple

     async def stream(self, messages: List[Dict[str, Any]]):
+        if self.response_model:
+            # For structured outputs, fall back to non-streaming
+            result, _ = await self.create(messages=messages)
+            if result:
+                yield result
+            return
+            
+        try:
             api_params = {
                 "model": self.model_name,
                 "temperature": self.temperature,
                 "messages": messages,
                 "stream": True,
             }
             if api_params["temperature"] == 0:
                 api_params["temperature"] = 0.1
     
             if self.model_name.startswith("o"):
                 api_params.pop("temperature", None)
     
             async with self.semaphore:
                 response = await self.client.chat.completions.create(**api_params)
                 async for chunk in response:
                     delta = chunk.choices[0].delta.content
                     if delta:
                         yield delta
+        except Exception as e:
+            logger.error(f"OpenAI streaming error: {str(e)}")
+            # Fall back to non-streaming
+            result, _ = await self.create(messages=messages)
+            if result:
+                yield result

+    def _preprocess_messages(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Helper method to preprocess messages for Anthropic API."""
+        processed_messages = []
+        for msg in messages:
+            if msg.get("role") == "developer":
+                processed_messages.append({"role": "system", "content": msg.get("content")})
+                logger.debug("Converted 'developer' role to 'system' for Anthropic call.")
+            else:
+                processed_messages.append(msg)
+        return processed_messages
+
     async def stream(self, messages: List[Dict[str, Any]], max_tokens: int = 4000):
-        processed_messages = []
-        for msg in messages:
-            if msg.get("role") == "developer":
-                processed_messages.append({"role": "system", "content": msg.get("content")})
-            else:
-                processed_messages.append(msg)
+        try:
+            processed_messages = self._preprocess_messages(messages)
+            # ... rest of the implementation
+        except Exception as e:
+            logger.error(f"Anthropic streaming error: {str(e)}")
+            # Fall back to non-streaming
+            result, _ = await self.create(messages=messages, max_tokens=max_tokens)
+            if result:
+                yield result